package com.ebupt.migu.music.common.auth;

import com.ebupt.migu.globalpopup.entity.ActivityInfo;
import com.ebupt.migu.music.common.constants.RoleConstants;
import com.ebupt.migu.music.common.exception.MyException;
import com.ebupt.migu.music.common.exception.StatusEnum;
import com.ebupt.migu.music.common.util.ReqestParamUtil;
import com.ebupt.migu.music.common.util.TokenUtils;
import com.ebupt.migu.music.system.entity.SysUser;
import com.ebupt.migu.music.system.mapper.RoleMapper;
import com.ebupt.migu.music.system.mapper.UserMapper;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by Intellij IDEA.
 * User:  liuyangyang@cd.ebupt.com
 * Date:  2019/9/29
 */
@Slf4j
@Service
public class IDAuthUtils {

    @Autowired
    private RoleMapper roleMapper;
    @Resource
    private UserMapper userMapper;

    /**
     * 是否创建人或者超级管理员
     * 查询： 查看本部门所有人群和策略
     *
     * @param request
     * @return
     */
    public boolean isCreatorOrAdmin(HttpServletRequest request) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
        Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params || null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        if (roles.contains(RoleConstants.SUPER_ADMIN)) {
            return true;
        }
        return false;
    }

    public boolean isCreatorOrAdmin(Map params,HttpServletRequest request) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
       /* Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params || null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }*/
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        if (roles.contains(RoleConstants.SUPER_ADMIN)) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否是创建人、管理员或者审核员
     *
     * @param request 页面请求参数
     * @return 判断结果
     */
    public boolean isCreatorOrAdminOrAuditor(HttpServletRequest request) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
        Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params || null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        return roles.contains(RoleConstants.SUPER_ADMIN) || roles.contains(RoleConstants.AUDITORBSL);
    }

    /**
     * 判断是否是创建人、管理员或者审核员
     * 针对Post请求，参数传入到body中的情况
     * @param request 页面请求参数
     * @return 判断结果
     */
    public boolean isCreatorOrAdminOrAuditorPost(HttpServletRequest request,Map<String,Object> params) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
//        Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params || null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        return roles.contains(RoleConstants.SUPER_ADMIN) || roles.contains(RoleConstants.AUDITORBSL);
    }

    /**
     * 判断是否是创建人、管理员或者审核员
     *
     * @param request 页面请求参数
     * @param activityInfo ActivityInfo对象
     * @return 判断结果
     */
    public boolean isCreatorOrAdminOrAuditor(HttpServletRequest request, ActivityInfo activityInfo) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
        if (activityInfo == null || activityInfo.getCreatorId() == null) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName(), creator = activityInfo.getCreatorId();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        return roles.contains(RoleConstants.SUPER_ADMIN) || roles.contains(RoleConstants.AUDITORBSL);
    }

    /**
     * 查询当前用户是否超级管理员
     *
     * @param params
     * @return
     */
    public Map<String, Object> isAdmin(Map<String, Object> params) {
        String id = params.get("cid").toString();
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(id);
        if (roles.contains(RoleConstants.SUPER_ADMIN)) {
            // 1- 是系统管理员
            params.put("isAdmin", "1");
        } else {
            // 0- 不是系统管理员
            params.put("isAdmin", "0");
        }
        if (roles.contains(RoleConstants.AUDITOR)) {
            params.put("isAuditor", "1");
        } else {
            params.put("isAuditor", "0");
        }

        if (roles.contains(RoleConstants.AUDITORBSL)) {
            params.put("isBSLAuditor", "1");
        } else {
            params.put("isBSLAuditor", "0");
        }

        //超级管理员
        if (roles.contains(RoleConstants.SUPERAIMIN)) {
            params.put("isSuperAdmin", "1");
        } else {
            params.put("isSuperAdmin", "0");
        }
        return params;
    }

    /**
     * 是否创建人或审核人或超级管理员
     * 查询： 查看本部门所有人群和策略
     *
     * @param request
     * @return
     */
    public boolean isCreatorOrApproverOrAdmin(HttpServletRequest request) {
        // 登录信息
        SysUser user = AuthBaseUtils.getSessionUser(request);
        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
        Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params || null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        if (null != params.get("approverId") && !"".equals(String.valueOf(params.get("approverId")))) {
            String approver = String.valueOf(params.get("approverId"));
            // 审核人可以操作
            if (operator.equals(approver)) {
                return true;
            }
        }
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        if (roles.contains(RoleConstants.SUPER_ADMIN)) {
            return true;
        }
        return false;
    }

    /**
     * 判断用户是否包含全量人群管理员角色
     * <br>
     * 用户群里列表查询专用
     *
     * @param map 请求参数
     * @return 带判断属性的请求参数
     */
    public Map<String, Object> isFullAmountGroupsAdmin(Map<String, Object> map) {
        // 获取用户id
        String id = map.get("cid").toString();
        // 获取用户的角色列表
        List<String> roleList = roleMapper.queryRoleIdByUserId(id);
        // 判断用户是否包含全量人群管理员角色
        if (roleList.contains(RoleConstants.FULL_AMOUNT_GROUPS_ADMIN)) {
            // 1 - 是管理员
            map.put("isFAGAdmin", "1");
        } else {
            // 0 - 不是管理员
            map.put("isFAGAdmin", "0");
        }
        return map;
    }

    /**
     * 是否创建人或者超级管理员
     * 查询： 查看本部门所有人群和策略
     *
     * @param request 请求信息
     * @return 判断结果
     */
    public boolean isCreatorOrAdminByToken(HttpServletRequest request) {
        String token = request.getHeader("token");
        // 解析token
        Claims claims = TokenUtils.parseJWT(token);

        // 获取loginName
        String loginName = claims.getId();
        log.info("用户登录账号：{}", loginName);
        Map<String, Object> login = new HashMap<>(3);
        login.put("pageStart", 0);
        login.put("rows", 9999);
        login.put("loginName", loginName);
        SysUser user = userMapper.queryByPage(login).get(0);

        if (StringUtils.isBlank(user.getLoginName())) {
            throw new MyException(StatusEnum.USER_VERIFICATION_FAILED, "请先登录系统");
        }
        // 请求参数
        Map<String, Object> params = ReqestParamUtil.getParams(request);
        if (null == params.get("creatorId")) {
            throw new MyException(StatusEnum.BUSINID, "访问参数异常");
        }
        // operator-当前提交请求的人； creator-人群或策略的创建人；
        String operator = user.getLoginName();
        String creator = params.get("creatorId").toString();
        // 本人可以操作自己创建的人群或策略
        if (operator.equals(creator)) {
            return true;
        }
        // 查询用户的角色列表
        List<String> roles = roleMapper.queryRoleIdByUserId(user.getId().toString());
        return roles.contains(RoleConstants.SUPER_ADMIN);
    }
}
